|
|
|
 |
Sie können alle drei Techniken nebeneinander verwenden, da sie sich nicht gegenseitig ausschließen. Welche Sie davon bevorzugt einsetzen, hängt von Ihnen selbst ab. Erstellen eines Menüs im Designer der FormAm einfachsten erstellen Sie ein Menü, indem Sie aus der Toolbox ein MenuStrip-Control in die Form oder auf die gewünschte Lasche des ToolStripContainers ziehen. Im noch leeren Menü in der Form können Sie nun die Beschriftung der einzelnen Menüelemente direkt eintragen – sowohl für die Hauptmenüelemente als auch für alle Unterelemente. Wünschen Sie die Darstellung als Combo- oder Textbox, öffnen Sie über die Pfeilschaltfläche einfach zu dem neuen Element die entsprechende Auswahlliste.
Abbildung 18.2 Auswahlliste der möglichen Menüelemente In den meisten Anwendungen ist ein Buchstabe der Beschriftung eines Menüelements unterstrichen. Durch Drücken der (Alt)-Taste in Kombination mit der Taste, die dem unterstrichenen Zeichen entspricht, wird das Untermenü dieses Hauptmenüpunkts geöffnet. Sie erzielen dieses Navigationsverhalten, wenn Sie vor den zu unterstreichenden Buchstaben ein »&«-Zeichen setzen. Um innerhalb des Menütextes ein »&«-Zeichen anzuzeigen, müssen im Text zwei »&«-Zeichen aufeinander folgen.
Trennstriche innerhalb eines Untermenüs zur optischen Unterstützung und Verdeutlichung von Gruppierungen erhalten Sie durch die Eingabe eines einfachen Bindestrichs (-). In diesem Moment wandelt sich der Typ ToolStripMenuItem in den Typ ToolStripSeparator um, der im Vergleich zum erstgenannten Typ naturgemäß deutlich weniger Eigenschaften aufweist. Sollten Sie zu einem späteren Zeitpunkt feststellen, dass die Anordnung der Menüelemente nicht optimal ist, können Sie diese mit der Maus verschieben. Nicht vergessen sollten Sie, jedem Menüelement einen beschreibenden Bezeichner im Eigenschaftsfenster zuzuweisen (Eigenschaft Name). Es ist nicht der guten Lesbarkeit des Programmcodes dienlich, wenn die vielleicht 30 verschiedenen Menüelemente toolStripMenuItem1 bis toolStripMenuItem30 heißen. Erstellen eines Menüs mit dem Elementauflistungs-EditorUm eine Menü zu erstellen, können Sie auch einen Assistenten starten. Dazu öffnen Sie über die Eigenschaft Items im Eigenschaftsfenster des MenuStrip-Objekts den Elementauflistungs-Editor, der Sie intuitiv bei der Zusammenstellung und weiteren Gestaltung des Menüs unterstützt (siehe Abbildung 18.3). Der Editor unterstützt Sie grundsätzlich nur bei der Erzeugung einer direkten Menüebene. Wollen Sie ausgehend von einem Menüelement ein Untermenü bereitstellen, klicken Sie auf die Eigenschaft DropDownItems des Menüelements – entweder im Elementauflistungs-Editor oder im Eigenschaftsfenster. Daraufhin öffnet sich eine weiteres Editorfenster, in dem Sie die nächste Menüebene definieren können.
Abbildung 18.3 Der Elementauflistungs-Editor Automatische Erzeugung eines MenüsDie Überschrift verspricht eigentlich zu viel. Natürlich können Sie kein vollständiges Hauptmenü einschließlich aller dazugehörigen Untermenüs automatisch erzeugen. Noch nicht, aber vielleicht in der übernächsten Version .NET 4.0. Immerhin, die meisten Menüs weisen in der Regel immer wieder vorkommende Menüeinträge auf, deren Untermenüs ebenfalls weitestgehend identisch sind (Datei, Bearbeiten, Optionen, Hilfe). Um Ihnen einen Teil der stupiden Tipparbeit abzunehmen, wird Ihnen unten im Eigenschaftsfenster der Link Standardelemente einfügen angeboten. Die eben erwähnten Menüelemente samt der üblichen Untermenüs werden dabei sofort erzeugt.
Abbildung 18.4 Der Link »Standardelemente hinzufügen« im Eigenschaftsfenster des »MenuStrip«-Objekts Elementanordnung mit »AllowItemRecorder« ändernNormalerweise haben alle Menüelemente eine feste Position zueinander: Links außen Datei, rechts daneben Bearbeiten usw. Das ist eine Konvention, an die Sie sich auch halten sollten. Nichtsdestotrotz können Sie es auch dem Benutzer überlassen, eine ganz individuelle Anordnung festzulegen. Allerdings müssen Sie ihm das auch ausdrücklich gestatten. Dafür dient die Eigenschaft AllowItemRecorder. Diese steht zunächst auf false und verbietet dem Anwender die Neuanordnung. Stellen Sie true ein, kann der Benutzer die Menüelemente mit der Maustaste bei gleichzeitig gedrückter (Alt)-Taste an die von ihm bevorzugte Position ziehen. Die Ausrichtung der Menüelemente im Container mit »LayoutStyle«Kann die Größe einer Form zur Laufzeit verändert werden, könnte das dazu führen, dass die Gesamtbreite der Menüzeile die Breite der Form überschreitet. Was passiert mit den Menüelementen, die rechts im Menü zu finden sind und keinen Platz mehr finden, um sich darzustellen? Versuchen Sie durch einen Test, die Antwort zu finden, werden Sie feststellen, dass die Menüelemente, die keinen ausreichenden Platz mehr finden, einfach nicht mehr angezeigt werden. Müssen Sie sicherstellen, dass der Anwender auch diese Menüpunkte auswählen kann, sollten Sie sich die Eigenschaft LayoutStyle genauer ansehen. Hier lautet die Einstellung HorizontalStackWithOverflow. LayoutStyle kann insgesamt fünf verschiedene Werte annehmen, die in der Enumeration ToolStripLayoutStyle vordefiniert sind.
Table und VerticalStackWithOverflow sind sehr ungewöhnlich und kommen wohl kaum in Betracht. StackWithOverflow lässt sich überhaupt nicht einstellen, stattdessen springt die Anzeige immer auf HorizontalStackWithOverflow zurück. Zurück zur Problematik des Überlaufs der Menüelemente. Dies können Sie mit der Einstellung Flow vermeiden. Die Menüelemente, die von Hause aus nicht mehr in eine Menüzeile passen, werden in eine zweite, neu eröffnete geschoben und stehen dem Anwender damit jederzeit zur Verfügung. In Abbildung 18.5 sehen Sie den Unterschied zwischen HorizontalStackWithOverflow und Flow.
Abbildung 18.5 Auswirkung der Einstellung der Eigenschaft »LayoutStyle« Die Menüleiste an einer anderen Seite der Form andockenNormalerweise werden Menüleisten immer oben in der Form angezeigt. Einige Programme gestatten es dem Anwender, das linke Ende der Menüleiste mit der Maus zu greifen und diese an einer anderen Seite der Form anzudocken. Dieses Feature steht auch Ihnen zur Verfügung. Sie müssen dazu nur die Eigenschaft GripStyle des MenuStrips auf Visible stellen, der Standard ist Hidden. Es werden dann drei Punkte am linken Rand angezeigt, die als Ausgangspunkt der Operation dienen. Eine Bedingung wird aber dabei an eine verschiebbare Menüleiste gestellt: Sie muss sich in einem ToolStripContainer befinden, denn nur dieser Container ist in der Lage, das Steuerelement neu auszurichten. Einen Nebeneffekt hat dabei jedoch die Einstellung der vorher besprochenen Eigenschaft LayoutStyle. Haben Sie diese nämlich auf Flow eingestellt, hat die Einstellung von GripStyle keine Auswirkungen: Die Ziehpunkte werden nicht angezeigt, und die Menüleiste ist nicht verschiebbar (siehe auch Abbildung 18.5).  18.2.3 Die Eigenschaften der Menüelemente »ToolStripMenuItem«
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| menuNeu.Text = "Neu"; |
Weiter oben habe ich bereits erwähnt, dass für ein Menüelement mit dem »&«-Zeichen ein Tastenkürzel festgelegt werden kann, mit dem das dem Menüelement zugeordnete Untermenü geöffnet wird. Zusätzlich zum Tastenkürzel in Verbindung mit der (Alt)-Taste kann ein Menüelement auch über eine vordefinierte Tastenkombination angesteuert werden, die in der Eigenschaft ShortcutKeys festgelegt wird.
Das im Framework 1.0/1.1 bereitgestellte Objekt MenuItem war in Bezug auf das Einstellen einer Tastenkombination ziemlich eingeschränkt, da nur bestimmte Kombinationen zugelassen waren, die in einer Enumeration definiert waren. ToolStripMenuItem hingegen lässt praktisch keine Vorstellung mehr unerfüllt. Sobald Sie die Pfeilschaltfläche in der Wertespalte der Eigenschaft ShortcutKeys anklicken, öffnet sich ein Hilfsfenster, in dem Sie die gewünschte Tastenkombination festlegen können (siehe Abbildung 18.6).
In der Auswahlliste Taste finden Sie nun auch Tasten aufgeführt, die bisher zur Bildung einer Tastenkombination nicht im Repertoire waren, darunter auch einige ziemlich exotisch anmutende. Diese werden in der Enumeration System.Windows.Forms.Keys beschrieben, der das Flags-Attribut angeheftet ist. Durch bitweise Verknüpfung können Sie deshalb auch ohne Unterstützung des Visual Studio die von Ihnen bevorzugte Tastenkombination per Code festlegen, z.B. (Strg)+(Shift)+(A) mit:
| this.menuItem.ShortcutKeys = Keys.Control | Keys.Shift | Keys.A; |
Hier klicken, um das Bild zu vergrößern
Abbildung 18.6 Hilfsfenster zur Festlegung eines Shortcuts
Standardmäßig wird die mit dem Menüelement verknüpfte Tastenkombination rechts neben der Menübeschriftung angezeigt. Diese Vorgabe kann mit der Eigenschaft ShortcutKeyDisplayString umgangen werden, indem Sie hier einfach die Zeichenfolge eintragen, die Sie dem Anwender anbieten wollen. Die Zeichenfolge wird auch dann angezeigt, wenn Sie dem Menüelement keinen Shortcut zugewiesen haben.
Falls Sie die Tastenkürzel nicht anzeigen wollen, können Sie die Eigenschaft ShowShortcutKeys abweichend von der Standardvorgabe auf false einstellen. Das müssen Sie gegebenenfalls für jeden Menüpunkt machen, denn eine übergeordnete Eigenschaft, die sich auf das gesamte Menü auswirkt, gibt es in dieser .NET-Version noch nicht.
a| Hinweis In Windows-Anwendungen haben sich bestimmte Tastenkombinationen für bestimmte Aktionen fest etabliert. Beispielsweise wird ein neues Dokument meist mit (Strg)+(N) geöffnet, gespeichert wird mit (Strg)+(S). Sie sollten sich, wenn möglich, an diese Konventionen halten, um den Anwendern, die es gewohnt sind, mit Tastenkombinationen zu arbeiten, die Einarbeitung in eine Anwendung zu erleichtern. |
Mit der Eigenschaft Visible und deren Einstellung false kann ein Menüelement unsichtbar gemacht werden. Bemerkenswert ist dabei die Wechselwirkung zwischen Visible und der Eigenschaft ShortcutKeys. Selbst dann, wenn ein Menüelement, dem eine Tastenkombination zugewiesen wird, mit Visible=false ausgeblendet wird, reagiert die Tastenkombination und führt den mit dem Click-Ereignis verknüpften Ereignishandler aus. Eine herrliche Spielwiese zur Implementierung undokumentierter Funktionalitäten.
Die Wirkungsweise der Eigenschaft Enabled ähnelt der von Visible nur auf den ersten Blick. Während Visible das betreffende Menüelement ausblendet, wird es mit Enabled=false deaktiviert, d. h., es wird abgeblendet und kann nicht ausgewählt werden. Der wesentliche Unterschied ist hierbei, dass ein deaktiviertes Menüelement auch nicht auf die ihm über ShortcutKeys zugewiesene Tastenkombination reagiert.
Menüelemente, die mit einem Häkchen versehen sind, verdeutlichen, ob die durch den Menüpunkt beschriebene Option gesetzt ist oder nicht. Diese Menüelemente bieten eine Auswahlmöglichkeit, die vergleichbar mit der einer Checkbox ist, sie arbeiten also wie ein »Ein-/Aus-Schalter«.
Voraussetzung dafür, dieses Verhalten einem Menüelement eigen zu machen, ist die Eigenschaft CheckedOnClick, die auf true gesetzt werden muss. Zur Laufzeit wird das Menüelement dann mit einem Häkchen versehen, wenn vor dem Anklicken kein Häkchen gesetzt war und umgekehrt. Das Markieren eines Menüelements mit einem Häkchen wird von der Eigenschaft Checked gesteuert. Legen Sie Checked=true fest, wird das Häkchen angezeigt.
ToolStripMenuItem bietet keine direkte Möglichkeit, anstelle des Häkchens einen ausgefüllten Kreis zu setzen, der ähnlich wie eine Gruppe von Radiobuttons signalisiert, dass nur eine von mehreren angebotenen Auswahloptionen ausgewählt werden kann. Können oder wollen Sie auf ein solches Feature nicht verzichten, haben Sie drei Alternativen:
|
Sie blenden ein Image im ToolStripMenuItem ein bzw. aus. |
|
|
Sie machen sich die Eigenschaft CheckState des Menüelements zunutze. |
|
|
Die Eigenschaft CheckState kennt drei Einstellungen, die in der gleichnamigen Enumeration vordefiniert sind: CheckState.Checked, CheckState.Unchecked und CheckState.Indeterminate. Letztere dient eigentlich dazu, einen nicht eindeutigen Zustand anzuzeigen, lässt sich aber durchaus auch für unser Vorhaben gebrauchen, denn zur Laufzeit wird zwar kein ausgefüllter Kreis, aber zumindest ein auf der Spitze stehendes Quadrat angezeigt. |
| Wenn Sie auf diese Weise einen Radiobutton-Effekt simulieren wollen, sollten Sie die Eigenschaft CheckOnClick=false einstellen. Im Click-Ereignis des Menüelements müssen Sie dann dafür sorgen, dass je nach Ausgangszustand zwischen CheckState.Unchecked und CheckState.Indeterminate umgeschaltet wird. Im folgenden Codefragment wird das gezeigt. | |
Hier klicken, um das Bild zu vergrößern
| private void menuRadio_Click(object sender, EventArgs e) { |
| if (menuRadio.CheckState == CheckState.Indeterminate) |
| menuRadio.CheckState = CheckState.Unchecked; |
| else if (menuRadio.CheckState == CheckState.Unchecked) |
| menuRadio.CheckState = CheckState.Indeterminate; |
| } |
| Die Wechselwirkung zwischen mehreren Menüelementen, die eine Gruppe bilden, aus der nur ein Menüelement markiert sein darf, müssen Sie natürlich selbst codieren. | |
Zu den optisch vorteilhaftesten Neuerungen der Menüelemente gehört die Anzeige eines Bildchens am linken Rand des Menüelements, die sich in den Menüs aller neueren Windows-Anwendungen etabliert haben. Zwar kann in einem MenuItem-Element ebenfalls ein Bildchen angezeigt werden (zur Erinnerung, das ist der Typ des Menüelements, der zu dem in die Tage gekommenen MainMenu aus .NET Framework 1.0/1.1 gehört), nur war diese Fähigkeit kein elementares Feature dieses Objekts, sondern bedurfte bisher für jedes einzelne Menüelement einen nicht unerheblichen Programmieraufwand. Ansonsten blieb nur noch die Alternative, das Steuerelement eines Drittanbieters einzusetzen. Die Klasse ToolStripMenuItem macht jetzt die Gestaltung eines Menüelements zu einem Kinderspiel.
Um ein Menüelement mit einem Symbol auszustatten, öffnen Sie über das Eigenschaftsfenster der Eigenschaft Image den Dialog Ressource auswählen. Importieren Sie hier das Symbol, das Sie dem Menüelement zuordnen möchten. Hier haben Sie zwei Möglichkeiten:
|
|
Sie wählen Lokale Ressource aus. |
|
|
Sie entscheiden sich für Projektressourcendatei. |
Welche Konsequenzen die Entscheidung für die eine oder andere Alternative hat, werde ich Ihnen am Ende des Buches in Kapitel 27 erläutern. Aber um es an dieser Stelle gleich vorwegzunehmen: Markieren Sie hier sinnvollerweise die lokale Ressource.
Hier klicken, um das Bild zu vergrößern
Abbildung 18.7 Das Dialogfenster »Ressource auswählen«
Unter Umständen sollten Sie unter ImageTransparentColor eine Farbe angeben, die Transparenz zulässt, so dass die Hintergrundfarbe des Symbols keinen unansehnlichen Effekt im Menü hinterlässt.
Wenn Sie wollen, stehen Ihnen über ein Bildchen hinaus weitere Möglichkeiten offen, jedes Menüelement individuell zu gestalten. Mit DisplayStyle können Sie festlegen, ob Sie sowohl das Symbol als auch den Text, nur das Symbol bzw. Text oder keines der beiden Elemente angezeigt haben wollen.
Tatsächlich lässt sich nun endlich in den Menüelementen auch die Schriftdarstellung mit der Eigenschaft Font problemlos beliebig anpassen. Sie können die Hintergrund- oder auch Schriftfarbe mit BackColor und ForeColor beeinflussen und zu guter Letzt auch mit BackgroundImage ein Hintergrundbildchen einbauen und dessen Darstellung mit BackgroundImageLayout innerhalb des Menüpunkts nach Belieben festlegen.
In einer Menüleiste eine Textbox oder ein Kombinationslistenfeld zu integrieren, ist ein neues Feature des .NET Frameworks 2.0. An dieser Stelle auf die Eigenschaften und Verhaltensweisen einzugehen, erübrigt sich, denn die beiden Steuerelemente unterscheiden sich nur geringfügig von denen, die Sie einer WinForm hinzufügen.
Wenn Sie schon mit dem .NET Framework 1.0/1.1 gearbeitet haben, werden Sie sicherlich hocherfreut darüber sein, mit welchen neuen Möglichkeiten die Gestaltung eines Menüs ausgestattet ist. Viele neue Eigenschaften ermöglichen es Ihnen, weitaus individueller ein Menü zu designen, als es bisher der Fall war. Dieser Zuwachs macht sich auch bei den Ereignissen bemerkbar, denn wie bei allen anderen Steuerelementen auch, löst das Ändern diverser Eigenschaften zur Laufzeit ein Ereignis aus.
Unter den vielen Ereignissen ist aber eigentlich nur ein Ereignis wichtig, nämlich Click. Dieses wird ausgelöst, wenn der Benutzer einen Menüpunkt anklickt. Enthält der Menüpunkt Unterpunkte, kommt es zu einer Ereigniskette:
|
|
DropDownOpening wird ausgelöst, wenn die Maus über einen Menüpunkt gezogen wird, der weitere Unterpunkte besitzt. Bei Auslösung des Ereignisses ist das Untermenü noch nicht geöffnet. |
|
|
DropDownOpened wird ausgelöst, nachdem sich das Untermenü geöffnet hat. |
|
|
Klickt der Anwender auf ein Element des Untermenüs, tritt zuerst DropDownItemClicked des übergeordneten Menüelements auf, bevor das Click-Ereignis des ausgewählten Menüelements endgültig dafür sorgt, dass die Anwendung das vom Benutzer gewünschte Verhalten zeigt. |
ToolStripMenuItem-Objekte können auch per Doppelklick aktiviert werden. Dazu muss die Eigenschaft DoubleClickEnabled=true gesetzt werden, die Standardvorgabe ist false. Allerdings wirkt sich ein Doppelklick nur auf die Elemente im Hauptmenü aus, da alle anderen Menüelemente schon nach dem Empfang des ersten Mausklicks geschlossen werden und einen Doppelklick nicht mehr verarbeiten können.
Alle Menüelemente reagieren auch auf alle Mausereignisse wie beispielsweise MouseMove, MouseDown und MouseUp. Wann diese Ereignisse ausgelöst werden und wie sie sinnvoll eingesetzt werden, erfahren Sie in einem späteren Kapitel.
Das folgende Programmbeispiel zeigt den Einsatz des Ereignisses DropDownOpening. Im Ereignishandler wird geprüft, ob sich in der Zwischenablage textuelle Daten befinden. Ist das Ergebnis der Prüfung positiv, wird das Untermenü Einfügen aktiviert angezeigt, ansonsten ist es deaktiviert. Der Anwender kann zur Laufzeit auf Einfügen klicken mit der Folge, dass eine Textbox den Inhalt der Zwischenablage anzeigt.
| // -------------------------------------------------------------- |
| // Beispiel: ...\Kapitel 18\DropDownOpeningDemo |
| // -------------------------------------------------------------- |
| private void menuBearbeiten_DropDownOpening(object sender, EventArgs e) { |
| // Prüfen, ob die Zwischenablage textuelle Daten enthält |
| if (Clipboard.GetDataObject().GetDataPresent(DataFormats.Text)) |
| menuEinfuegen.Enabled = true; |
| else |
| menuEinfuegen.Enabled = false; |
| } |
| private void menuEinfuegen_Click(object sender, EventArgs e) { |
| IDataObject myData = Clipboard.GetDataObject(); |
| txtClipboxContent.Text = (string)myData.GetData(typeof(string)); |
| } |
Mit der Klasse Clipboard, die Methoden bereitstellt, um mit der Zwischenablage Daten auszutauschen, werden wir uns weiter unten in Abschnitt 18.4 noch intensiver beschäftigen.
Im folgenden Beispiel enthält die Form zwei Textboxen, die durch ein Splitter-Steuerelement voneinander getrennt sind. Ein Splitter dient dazu, einen Clientbereich in mehrere einzelne, voneinander unabhängige Bereiche aufzuteilen. Die Teilbereiche werden meist von Steuerelementen vollständig beansprucht (Einstellung Dock=Fill). Zur Laufzeit kann der Benutzer mit der Maus den Splitter greifen und nach eigenem Ermessen die Teilbereiche verkleinern oder vergrößern, ähnlich wie im Windows Explorer.
Das Menü ist in ein ToolStripContainer-Steuerelement eingebettet. Das wäre im vorliegenden Fall zwar nicht notwendig, aber die gezeigte Form soll im Verlauf des Kapitels noch weiter entwickelt werden und neben einer Status- auch eine Symbolleiste erhalten, die innerhalb der Form verschoben werden soll.
Das Hauptmenü hat die drei Menüpunkte Datei, Bearbeiten und Optionen nebst den wichtigsten Untermenüelementen. Optionen hat nur einen Untermenüpunkt (Hintergrundfarbe), der selbst eine weitere Untermenüebene hat. In dieser werden vier Menüelemente angezeigt, von denen der Benutzer die gewünschte Hintergrundfarbe der beiden Textboxen auswählen kann. Die aktuelle Hintergrundfarbe ist mit einem Häkchen versehen.
In diesem Beispiel sind bereits die Untermenüelemente von Bearbeiten enthalten, jedoch noch ohne Programmcode. Dazu muss ich Ihnen zuerst noch die Programmierung der Zwischenablage weiter unten in diesem Kapitel vorstellen. Die Anwendung ist jedoch bereits in der Lage, Dateien in der oberen Textbox zu öffnen, diese zu bearbeiten und anschließend auf einfache Weise zu speichern. Außerdem wird gezeigt, wie Sie die Unterelemente von Hintergrundfarbe codieren können.
Hier klicken, um das Bild zu vergrößern
Abbildung 18.8 Das Fenster des Beispiels »MenuStripDemo«
| // -------------------------------------------------------------- |
| // Beispiel: ...\Kapitel 18\MenuStripDemo |
| // -------------------------------------------------------------- |
| public partial class Form1 : Form { |
| // Ereignishandler der Click-Ereignisse der Menüelemente, mit denen |
| // die Hintergrundfarben der Textboxen geändert werden können |
| private void ChangeColor(object sender, EventArgs e) { |
| foreach (ToolStripMenuItem temp in menuHintergrundfarbe.DropDownItems) |
| temp.Checked = false; |
| switch (((ToolStripMenuItem)sender).Text) { |
| case "Weiß": |
| txtOben.BackColor = Color.White; |
| txtUnten.BackColor = Color.White; |
| menuWeiss.Checked = true; |
| break; |
| case "Rot": |
| txtOben.BackColor = Color.Red; |
| txtUnten.BackColor = Color.Red; |
| menuRot.Checked = true; |
| break; |
| case "Gelb": |
| txtOben.BackColor = Color.Yellow; |
| txtUnten.BackColor = Color.Yellow; |
| menuGelb.Checked = true; |
| break; |
| case "Blau": |
| txtOben.BackColor = Color.Blue; |
| txtUnten.BackColor = Color.Blue; |
| menuBlau.Checked = true; |
| break; |
| } |
| } |
| // Menü 'Neu' leert beide Textboxen |
| private void menuNeu_Click(object sender, EventArgs e) { |
| this.txtOben.Text = ""; |
| this.txtUnten.Text = ""; |
| } |
| // eine vorhandene Datei öffnen |
| private void menuOeffnen_Click(object sender, EventArgs e) { |
| openFileDialog1.Filter = "Text-Dateien (.txt)|*.txt|Alle Dateien (*.*)|*.*"; |
| DialogResult result = openFileDialog1.ShowDialog(); |
| try { |
| if (result == DialogResult.OK) { |
| StreamReader sr = new StreamReader(openFileDialog1.FileName); |
| txtOben.Text = sr.ReadToEnd(); |
| sr.Close(); |
| } |
| } |
| catch (Exception ex) { |
| MessageBox.Show(ex.Message, "Texteditor"); |
| } |
| } |
| // den Inhalt der oberen Textbox speichern |
| private void menuSpeichernUnter_Click(object sender, EventArgs e) { |
| DialogResult result = saveFileDialog1.ShowDialog(); |
| try { |
| if (result == DialogResult.OK) { |
| StreamWriter sw = new StreamWriter(saveFileDialog1.FileName, false); |
| sw.Write(txtOben.Text); |
| sw.Close(); |
| } |
| } |
| catch (Exception ex) { |
| MessageBox.Show(ex.Message); |
| } |
| } |
| private void menuBeenden_Click(object sender, EventArgs e) { |
| Application.Exit(); |
| } |
| } |
Auf den Code zum Öffnen und Speichern einer Datei in den jeweiligen Ereignishandlern der entsprechenden Menüelemente gehe ich an dieser Stelle nicht ein. Sie können das im Bedarfsfall in Kapitel 17 nachlesen. Sehen wir uns vielmehr die Methode ChangeColor an, die als gemeinsamer Ereignishandler für alle Click-Ereignisse der Untermenüelemente von Hintergrundfarbe dient. Die Verknüpfung wurde im Eigenschaftsfenster vorgenommen.
Zuerst wird in einer foreach-Schleife die Auflistung der farbgebenden Menüebene durchlaufen. Die Referenz auf die Auflistung liefert die Eigenschaft DropDownItems des Objekts menuHintergrundfarbe.
| foreach (ToolStripMenuItem temp in menuHintergrundfarbe.DropDownItems) |
| temp.Checked = false; |
Der Zustand Checked jedes Menüelements wird in der Schleife auf false gesetzt. Das ist schneller und einfacher, als jedes Element dahingehend zu untersuchen, ob das Häkchen gesetzt ist oder nicht.
Je nach Wahl des Anwenders muss nun die Hintergrundfarbe der Textboxen angepasst und das dazugehörige Menüelement markiert werden. Um festzustellen, welches Element für den Aufruf von ChangeColor gesorgt hat, muss der Parameter sender untersucht werden. Da wir wissen, dass ein Objekt vom Typ ToolStripItem hinter dem Aufruf steckt, können wir sender sofort konvertieren.
Nun muss aus dem Reigen der denkbaren Ereignisauslöser der konkrete ermittelt werden. Es bietet sich dazu an, die Eigenschaft Text auszuwerten. Das Ergebnis der Untersuchung wird einer switch-Anweisung als Ausdruck übergeben.
| switch (((ToolStripMenuItem)sender).Text) |
In den case-Zweigen wird anschließend die Hintergrundfarbe passend gesetzt und das dafür zuständige Menüelement mit einem Häkchen versehen.
| << zurück |
|
||||||||||||||
 |
||||||||||||||
|
||||||||||||||
|
||||||||||||||
|
||||||||||||||
|
||||||||||||||
|
||||||||||||||
Copyright © Galileo Press 2006
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.
